﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a MLP OCR classifier.</summary>
	// Token: 0x02000054 RID: 84
	[Serializable]
	public class HOCRMlp : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06000C09 RID: 3081 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRMlp() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x06000C0A RID: 3082 RVA: 0x0004C0D2 File Offset: 0x0004A2D2
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRMlp(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000C0B RID: 3083 RVA: 0x0004C0E1 File Offset: 0x0004A2E1
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRMlp(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000C0C RID: 3084 RVA: 0x0004C0F0 File Offset: 0x0004A2F0
		private void AssertSemType()
		{
			base.AssertSemType("ocr_mlp");
		}

		// Token: 0x06000C0D RID: 3085 RVA: 0x0004C0FD File Offset: 0x0004A2FD
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HOCRMlp obj)
		{
			obj = new HOCRMlp(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06000C0E RID: 3086 RVA: 0x0004C118 File Offset: 0x0004A318
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HOCRMlp[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HOCRMlp[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HOCRMlp(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read an OCR classifier from a file.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C0F RID: 3087 RVA: 0x0004C188 File Offset: 0x0004A388
		public HOCRMlp(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(694);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a multilayer perceptron.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="numHidden">Number of hidden units of the MLP. Default: 80</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "none"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		/// <param name="randSeed">Seed value of the random number generator that is used to initialize the MLP with random values. Default: 42</param>
		// Token: 0x06000C10 RID: 3088 RVA: 0x0004C1D4 File Offset: 0x0004A3D4
		public HOCRMlp(int widthCharacter, int heightCharacter, string interpolation, HTuple features, HTuple characters, int numHidden, string preprocessing, int numComponents, int randSeed)
		{
			IntPtr proc = HalconAPI.PreCall(708);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.Store(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreI(proc, 5, numHidden);
			HalconAPI.StoreS(proc, 6, preprocessing);
			HalconAPI.StoreI(proc, 7, numComponents);
			HalconAPI.StoreI(proc, 8, randSeed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a multilayer perceptron.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="numHidden">Number of hidden units of the MLP. Default: 80</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "none"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		/// <param name="randSeed">Seed value of the random number generator that is used to initialize the MLP with random values. Default: 42</param>
		// Token: 0x06000C11 RID: 3089 RVA: 0x0004C274 File Offset: 0x0004A474
		public HOCRMlp(int widthCharacter, int heightCharacter, string interpolation, string features, HTuple characters, int numHidden, string preprocessing, int numComponents, int randSeed)
		{
			IntPtr proc = HalconAPI.PreCall(708);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.StoreS(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreI(proc, 5, numHidden);
			HalconAPI.StoreS(proc, 6, preprocessing);
			HalconAPI.StoreI(proc, 7, numComponents);
			HalconAPI.StoreI(proc, 8, randSeed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06000C12 RID: 3090 RVA: 0x0004C310 File Offset: 0x0004A510
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassMlp();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06000C13 RID: 3091 RVA: 0x0004C348 File Offset: 0x0004A548
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRMlp(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeOcrClassMlp(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06000C14 RID: 3092 RVA: 0x0004C388 File Offset: 0x0004A588
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassMlp();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000C15 RID: 3093 RVA: 0x0004C39C File Offset: 0x0004A59C
		public new static HOCRMlp Deserialize(Stream stream)
		{
			HOCRMlp hocrmlp = new HOCRMlp();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hocrmlp.DeserializeOcrClassMlp(hserializedItem);
			hserializedItem.Dispose();
			return hocrmlp;
		}

		// Token: 0x06000C16 RID: 3094 RVA: 0x0004C3C2 File Offset: 0x0004A5C2
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000C17 RID: 3095 RVA: 0x0004C3CC File Offset: 0x0004A5CC
		public new HOCRMlp Clone()
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassMlp();
			HOCRMlp hocrmlp = new HOCRMlp();
			hocrmlp.DeserializeOcrClassMlp(hserializedItem);
			hserializedItem.Dispose();
			return hocrmlp;
		}

		/// <summary>
		///   Select an optimal combination of features to classify OCR data from a (protected) training file.
		///   Modified instance represents: Trained OCR-MLP classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C18 RID: 3096 RVA: 0x0004C3F4 File Offset: 0x0004A5F4
		public HTuple SelectFeatureSetTrainfMlpProtected(HTuple trainingFile, HTuple password, HTuple featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(661);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, password);
			HalconAPI.Store(proc, 2, featureList);
			HalconAPI.StoreS(proc, 3, selectionMethod);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(password);
			HalconAPI.UnpinTuple(featureList);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select an optimal combination of features to classify OCR data from a (protected) training file.
		///   Modified instance represents: Trained OCR-MLP classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C19 RID: 3097 RVA: 0x0004C4C8 File Offset: 0x0004A6C8
		public HTuple SelectFeatureSetTrainfMlpProtected(string trainingFile, string password, string featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(661);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, password);
			HalconAPI.StoreS(proc, 2, featureList);
			HalconAPI.StoreS(proc, 3, selectionMethod);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selects an optimal combination of features to classify OCR data.
		///   Modified instance represents: Trained OCR-MLP classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C1A RID: 3098 RVA: 0x0004C588 File Offset: 0x0004A788
		public HTuple SelectFeatureSetTrainfMlp(HTuple trainingFile, HTuple featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(662);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, featureList);
			HalconAPI.StoreS(proc, 2, selectionMethod);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(featureList);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selects an optimal combination of features to classify OCR data.
		///   Modified instance represents: Trained OCR-MLP classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C1B RID: 3099 RVA: 0x0004C64C File Offset: 0x0004A84C
		public HTuple SelectFeatureSetTrainfMlp(string trainingFile, string featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(662);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, featureList);
			HalconAPI.StoreS(proc, 2, selectionMethod);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Clear an OCR classifier.</summary>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		// Token: 0x06000C1C RID: 3100 RVA: 0x0004C704 File Offset: 0x0004A904
		public static void ClearOcrClassMlp(HOCRMlp[] OCRHandle)
		{
			HTuple htuple = HHandleBase.ConcatArray(OCRHandle);
			IntPtr proc = HalconAPI.PreCall(691);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(OCRHandle);
		}

		/// <summary>
		///   Clear an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		// Token: 0x06000C1D RID: 3101 RVA: 0x0004C748 File Offset: 0x0004A948
		public void ClearOcrClassMlp()
		{
			IntPtr proc = HalconAPI.PreCall(691);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Deserialize a serialized MLP-based OCR classifier.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000C1E RID: 3102 RVA: 0x0004C77C File Offset: 0x0004A97C
		public void DeserializeOcrClassMlp(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(692);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a MLP-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000C1F RID: 3103 RVA: 0x0004C7D0 File Offset: 0x0004A9D0
		public HSerializedItem SerializeOcrClassMlp()
		{
			IntPtr proc = HalconAPI.PreCall(693);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read an OCR classifier from a file.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C20 RID: 3104 RVA: 0x0004C818 File Offset: 0x0004AA18
		public void ReadOcrClassMlp(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(694);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write an OCR classifier to a file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C21 RID: 3105 RVA: 0x0004C864 File Offset: 0x0004AA64
		public void WriteOcrClassMlp(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(695);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the features of a character.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Input character.</param>
		/// <param name="transform">Should the feature vector be transformed with the preprocessing? Default: "true"</param>
		/// <returns>Feature vector of the character.</returns>
		// Token: 0x06000C22 RID: 3106 RVA: 0x0004C8A0 File Offset: 0x0004AAA0
		public HTuple GetFeaturesOcrClassMlp(HImage character, string transform)
		{
			IntPtr proc = HalconAPI.PreCall(696);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.StoreS(proc, 1, transform);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06000C23 RID: 3107 RVA: 0x0004C900 File Offset: 0x0004AB00
		public HTuple DoOcrWordMlp(HRegion character, HImage image, string expression, int numAlternatives, int numCorrections, out HTuple confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(697);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06000C24 RID: 3108 RVA: 0x0004C9B8 File Offset: 0x0004ABB8
		public string DoOcrWordMlp(HRegion character, HImage image, string expression, int numAlternatives, int numCorrections, out double confidence, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(697);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			num = HalconAPI.LoadS(proc, 2, num, out word);
			num = HalconAPI.LoadD(proc, 3, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06000C25 RID: 3109 RVA: 0x0004CA70 File Offset: 0x0004AC70
		public HTuple DoOcrMultiClassMlp(HRegion character, HImage image, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(698);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="confidence">Confidence of the class of the characters.</param>
		/// <returns>Result of classifying the characters with the MLP.</returns>
		// Token: 0x06000C26 RID: 3110 RVA: 0x0004CAE8 File Offset: 0x0004ACE8
		public string DoOcrMultiClassMlp(HRegion character, HImage image, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(698);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Character to be recognized.</param>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the MLP.</returns>
		// Token: 0x06000C27 RID: 3111 RVA: 0x0004CB60 File Offset: 0x0004AD60
		public HTuple DoOcrSingleClassMlp(HRegion character, HImage image, HTuple num, out HTuple confidence)
		{
			IntPtr proc = HalconAPI.PreCall(699);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			HTuple result;
			num2 = HTuple.LoadNew(proc, 0, num2, out result);
			num2 = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify a single character with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Character to be recognized.</param>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <param name="confidence">Confidence(s) of the class(es) of the character.</param>
		/// <returns>Result of classifying the character with the MLP.</returns>
		// Token: 0x06000C28 RID: 3112 RVA: 0x0004CBE8 File Offset: 0x0004ADE8
		public string DoOcrSingleClassMlp(HRegion character, HImage image, HTuple num, out double confidence)
		{
			IntPtr proc = HalconAPI.PreCall(699);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			string result;
			num2 = HalconAPI.LoadS(proc, 0, num2, out result);
			num2 = HalconAPI.LoadD(proc, 1, num2, out confidence);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier with data from a (protected) training file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="maxIterations">Maximum number of iterations of the optimization algorithm. Default: 200</param>
		/// <param name="weightTolerance">Threshold for the difference of the weights of the MLP between two iterations of the optimization algorithm. Default: 1.0</param>
		/// <param name="errorTolerance">Threshold for the difference of the mean error of the MLP on the training data between two iterations of the optimization algorithm. Default: 0.01</param>
		/// <param name="errorLog">Mean error of the MLP on the training data as a function of the number of iterations of the optimization algorithm.</param>
		/// <returns>Mean error of the MLP on the training data.</returns>
		// Token: 0x06000C29 RID: 3113 RVA: 0x0004CC70 File Offset: 0x0004AE70
		public double TrainfOcrClassMlpProtected(HTuple trainingFile, HTuple password, int maxIterations, double weightTolerance, double errorTolerance, out HTuple errorLog)
		{
			IntPtr proc = HalconAPI.PreCall(700);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.Store(proc, 2, password);
			HalconAPI.StoreI(proc, 3, maxIterations);
			HalconAPI.StoreD(proc, 4, weightTolerance);
			HalconAPI.StoreD(proc, 5, errorTolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(password);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out errorLog);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier with data from a (protected) training file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="maxIterations">Maximum number of iterations of the optimization algorithm. Default: 200</param>
		/// <param name="weightTolerance">Threshold for the difference of the weights of the MLP between two iterations of the optimization algorithm. Default: 1.0</param>
		/// <param name="errorTolerance">Threshold for the difference of the mean error of the MLP on the training data between two iterations of the optimization algorithm. Default: 0.01</param>
		/// <param name="errorLog">Mean error of the MLP on the training data as a function of the number of iterations of the optimization algorithm.</param>
		/// <returns>Mean error of the MLP on the training data.</returns>
		// Token: 0x06000C2A RID: 3114 RVA: 0x0004CD04 File Offset: 0x0004AF04
		public double TrainfOcrClassMlpProtected(string trainingFile, string password, int maxIterations, double weightTolerance, double errorTolerance, out HTuple errorLog)
		{
			IntPtr proc = HalconAPI.PreCall(700);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, password);
			HalconAPI.StoreI(proc, 3, maxIterations);
			HalconAPI.StoreD(proc, 4, weightTolerance);
			HalconAPI.StoreD(proc, 5, errorTolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out errorLog);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="maxIterations">Maximum number of iterations of the optimization algorithm. Default: 200</param>
		/// <param name="weightTolerance">Threshold for the difference of the weights of the MLP between two iterations of the optimization algorithm. Default: 1.0</param>
		/// <param name="errorTolerance">Threshold for the difference of the mean error of the MLP on the training data between two iterations of the optimization algorithm. Default: 0.01</param>
		/// <param name="errorLog">Mean error of the MLP on the training data as a function of the number of iterations of the optimization algorithm.</param>
		/// <returns>Mean error of the MLP on the training data.</returns>
		// Token: 0x06000C2B RID: 3115 RVA: 0x0004CD8C File Offset: 0x0004AF8C
		public double TrainfOcrClassMlp(HTuple trainingFile, int maxIterations, double weightTolerance, double errorTolerance, out HTuple errorLog)
		{
			IntPtr proc = HalconAPI.PreCall(701);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.StoreI(proc, 2, maxIterations);
			HalconAPI.StoreD(proc, 3, weightTolerance);
			HalconAPI.StoreD(proc, 4, errorTolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out errorLog);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="maxIterations">Maximum number of iterations of the optimization algorithm. Default: 200</param>
		/// <param name="weightTolerance">Threshold for the difference of the weights of the MLP between two iterations of the optimization algorithm. Default: 1.0</param>
		/// <param name="errorTolerance">Threshold for the difference of the mean error of the MLP on the training data between two iterations of the optimization algorithm. Default: 0.01</param>
		/// <param name="errorLog">Mean error of the MLP on the training data as a function of the number of iterations of the optimization algorithm.</param>
		/// <returns>Mean error of the MLP on the training data.</returns>
		// Token: 0x06000C2C RID: 3116 RVA: 0x0004CE10 File Offset: 0x0004B010
		public double TrainfOcrClassMlp(string trainingFile, int maxIterations, double weightTolerance, double errorTolerance, out HTuple errorLog)
		{
			IntPtr proc = HalconAPI.PreCall(701);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreI(proc, 2, maxIterations);
			HalconAPI.StoreD(proc, 3, weightTolerance);
			HalconAPI.StoreD(proc, 4, errorTolerance);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out errorLog);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the information content of the preprocessed feature vectors of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "principal_components"</param>
		/// <param name="cumInformationCont">Cumulative information content of the transformed feature vectors.</param>
		/// <returns>Relative information content of the transformed feature vectors.</returns>
		// Token: 0x06000C2D RID: 3117 RVA: 0x0004CE90 File Offset: 0x0004B090
		public HTuple GetPrepInfoOcrClassMlp(HTuple trainingFile, string preprocessing, out HTuple cumInformationCont)
		{
			IntPtr proc = HalconAPI.PreCall(702);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, preprocessing);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cumInformationCont);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the information content of the preprocessed feature vectors of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "principal_components"</param>
		/// <param name="cumInformationCont">Cumulative information content of the transformed feature vectors.</param>
		/// <returns>Relative information content of the transformed feature vectors.</returns>
		// Token: 0x06000C2E RID: 3118 RVA: 0x0004CF04 File Offset: 0x0004B104
		public HTuple GetPrepInfoOcrClassMlp(string trainingFile, string preprocessing, out HTuple cumInformationCont)
		{
			IntPtr proc = HalconAPI.PreCall(702);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, preprocessing);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cumInformationCont);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the rejection class parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the general parameter. Default: "sampling_strategy"</param>
		/// <returns>Value of the general parameter.</returns>
		// Token: 0x06000C2F RID: 3119 RVA: 0x0004CF70 File Offset: 0x0004B170
		public HTuple GetRejectionParamsOcrClassMlp(HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(703);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the rejection class parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the general parameter. Default: "sampling_strategy"</param>
		/// <returns>Value of the general parameter.</returns>
		// Token: 0x06000C30 RID: 3120 RVA: 0x0004CFC8 File Offset: 0x0004B1C8
		public string GetRejectionParamsOcrClassMlp(string genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(703);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the rejection class parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the general parameter. Default: "sampling_strategy"</param>
		/// <param name="genParamValue">Value of the general parameter. Default: "hyperbox_around_all_classes"</param>
		// Token: 0x06000C31 RID: 3121 RVA: 0x0004D018 File Offset: 0x0004B218
		public void SetRejectionParamsOcrClassMlp(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(704);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the rejection class parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the general parameter. Default: "sampling_strategy"</param>
		/// <param name="genParamValue">Value of the general parameter. Default: "hyperbox_around_all_classes"</param>
		// Token: 0x06000C32 RID: 3122 RVA: 0x0004D068 File Offset: 0x0004B268
		public void SetRejectionParamsOcrClassMlp(string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(704);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the regularization parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the regularization parameter to return. Default: "weight_prior"</param>
		/// <returns>Value of the regularization parameter.</returns>
		// Token: 0x06000C33 RID: 3123 RVA: 0x0004D0AC File Offset: 0x0004B2AC
		public HTuple GetRegularizationParamsOcrClassMlp(string genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(705);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the regularization parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the regularization parameter to return. Default: "weight_prior"</param>
		/// <param name="genParamValue">Value of the regularization parameter. Default: 1.0</param>
		// Token: 0x06000C34 RID: 3124 RVA: 0x0004D0FC File Offset: 0x0004B2FC
		public void SetRegularizationParamsOcrClassMlp(string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(706);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the regularization parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="genParamName">Name of the regularization parameter to return. Default: "weight_prior"</param>
		/// <param name="genParamValue">Value of the regularization parameter. Default: 1.0</param>
		// Token: 0x06000C35 RID: 3125 RVA: 0x0004D148 File Offset: 0x0004B348
		public void SetRegularizationParamsOcrClassMlp(string genParamName, double genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(706);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreD(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters.</param>
		/// <param name="features">Features to be used for classification.</param>
		/// <param name="characters">Characters of the character set to be read.</param>
		/// <param name="numHidden">Number of hidden units of the MLP.</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors.</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features.</param>
		// Token: 0x06000C36 RID: 3126 RVA: 0x0004D18C File Offset: 0x0004B38C
		public void GetParamsOcrClassMlp(out int widthCharacter, out int heightCharacter, out string interpolation, out HTuple features, out HTuple characters, out int numHidden, out string preprocessing, out int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(707);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out widthCharacter);
			num = HalconAPI.LoadI(proc, 1, num, out heightCharacter);
			num = HalconAPI.LoadS(proc, 2, num, out interpolation);
			num = HTuple.LoadNew(proc, 3, num, out features);
			num = HTuple.LoadNew(proc, 4, num, out characters);
			num = HalconAPI.LoadI(proc, 5, num, out numHidden);
			num = HalconAPI.LoadS(proc, 6, num, out preprocessing);
			num = HalconAPI.LoadI(proc, 7, num, out numComponents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters.</param>
		/// <param name="features">Features to be used for classification.</param>
		/// <param name="characters">Characters of the character set to be read.</param>
		/// <param name="numHidden">Number of hidden units of the MLP.</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors.</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features.</param>
		// Token: 0x06000C37 RID: 3127 RVA: 0x0004D258 File Offset: 0x0004B458
		public void GetParamsOcrClassMlp(out int widthCharacter, out int heightCharacter, out string interpolation, out string features, out HTuple characters, out int numHidden, out string preprocessing, out int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(707);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out widthCharacter);
			num = HalconAPI.LoadI(proc, 1, num, out heightCharacter);
			num = HalconAPI.LoadS(proc, 2, num, out interpolation);
			num = HalconAPI.LoadS(proc, 3, num, out features);
			num = HTuple.LoadNew(proc, 4, num, out characters);
			num = HalconAPI.LoadI(proc, 5, num, out numHidden);
			num = HalconAPI.LoadS(proc, 6, num, out preprocessing);
			num = HalconAPI.LoadI(proc, 7, num, out numComponents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a multilayer perceptron.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="numHidden">Number of hidden units of the MLP. Default: 80</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "none"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		/// <param name="randSeed">Seed value of the random number generator that is used to initialize the MLP with random values. Default: 42</param>
		// Token: 0x06000C38 RID: 3128 RVA: 0x0004D324 File Offset: 0x0004B524
		public void CreateOcrClassMlp(int widthCharacter, int heightCharacter, string interpolation, HTuple features, HTuple characters, int numHidden, string preprocessing, int numComponents, int randSeed)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(708);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.Store(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreI(proc, 5, numHidden);
			HalconAPI.StoreS(proc, 6, preprocessing);
			HalconAPI.StoreI(proc, 7, numComponents);
			HalconAPI.StoreI(proc, 8, randSeed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a multilayer perceptron.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="numHidden">Number of hidden units of the MLP. Default: 80</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "none"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		/// <param name="randSeed">Seed value of the random number generator that is used to initialize the MLP with random values. Default: 42</param>
		// Token: 0x06000C39 RID: 3129 RVA: 0x0004D3C4 File Offset: 0x0004B5C4
		public void CreateOcrClassMlp(int widthCharacter, int heightCharacter, string interpolation, string features, HTuple characters, int numHidden, string preprocessing, int numComponents, int randSeed)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(708);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.StoreS(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreI(proc, 5, numHidden);
			HalconAPI.StoreS(proc, 6, preprocessing);
			HalconAPI.StoreI(proc, 7, numComponents);
			HalconAPI.StoreI(proc, 8, randSeed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}
	}
}
